#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
#include <string>

using namespace std;
//void PrintArray(int* array, int n)
//{
//	for (int i = 0; i < n; i++)
//		std::cout << array[i] << " ";
//	std::cout << std::endl;
//}
//int main()
//{
//	int array[] = { 4, 1, 7, 8, 3, 9, 0 };
//	int n = sizeof(array) / sizeof(array[0]);
//	// 升序排序
//	std::sort(array, array + n);
//	PrintArray(array, n);
//
//	// 降序排序，需要改变比较规则
//	std::sort(array, array + n, std::greater<int>());
//	PrintArray(array, n);
//}



//struct goods
//{
//	std::string _name; 
//	double _price;
//	int _evaluate; // 评价
//	goods(std::string name, double price, int evaluate):
//		_name(name), 
//		_price(price), 
//		_evaluate(evaluate)
//	{}
//};
//
//// 仿函数，升序的比较规则
//struct comparePriceLess
//{
//	bool operator()(const goods& left, const goods& right)
//	{
//		return left._price < right._price;
//	}
//};
//// 仿函数，降序比较规则
//struct comparePriceGreater
//{
//	bool operator()(const goods& left, const goods& right)
//	{
//		return left._price > right._price;
//	}
//};
//
//int main()
//{
//	std::vector<goods> list = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,3 }, { "菠萝", 1.5, 4} };
//
//	// 按价格升序排序
//	std::sort(list.begin(), list.end(), [](const goods& left, const goods& right) {
//		return left._price < right._price;
//		});
//	
//	// 按价格降序排序
//	std::sort(list.begin(), list.end(), [](const goods& left, const goods& right) {
//		return left._price > right._price;
//		});
//
//	// 按评价升序排序
//	std::sort(list.begin(), list.end(), [](const goods& left, const goods& right) {
//		return left._evaluate < right._evaluate;
//		});
//	
//	// 按评价降序排序
//	std::sort(list.begin(), list.end(), [](const goods& left, const goods& right) {
//		return left._evaluate > right._evaluate;
//		});
//	return 0;
//}

//int main()
//{
//	// 最最简单的lambda表达式，没有任何作用
//	[] {};
//
//	// 忽略参数列表和返回值类型
//	int a = 1, b = 2;
//	[=] {return a + b; }; 
//
//	// 无返回值，可以不写返回值类型
//	auto func1 = [&](int c) {b = a + c; };
//	func1(10);
//	std::cout << a << " " << b << std::endl;
//	
//	// 一个写得非常完整的lambda表达式 
//	auto func2 = [=, &b](int c) {b += a + c; };
//	func2(10);
//	std::cout << a << " " << b << std::endl;
//}

//void (*PF)();
//int main()
//{
//	auto func1 = []() {std::cout << "hello world" << std::endl; };
//	auto func2 = []() {std::cout << "hello world" << std::endl; };
//
//	// 编译器报错，显示没有匹配的赋值运算符重载
//	// func1 = func2; 
//
//	// 但是可以通过拷贝构造赋值
//	auto func3(func2); 
//
//	// 可以将lambda表达式赋值给相同类型的函数指针
//	PF = func1;
//	PF();
//
//	return 0;
//}

//void (*PF)();
//int main()
//{
//	auto func1 = []() {std::cout << "hello world" << std::endl; };
//	auto func2 = []() {std::cout << "hello world" << std::endl; };
//
//	std::cout << typeid(func1).name() << std::endl;
//	std::cout << typeid(func2).name() << std::endl;
//
//	func1();
//	func2();
//
//	return 0;
//}

//class AA
//{
//public:
//	void func()
//	{
//		auto f = [this]() {
//			std::cout << a << std::endl;
//			std::cout << b << std::endl;
//		};
//	}
//private:
//	int a;
//	int b;
//};
//int main()
//{
//
//	return 0;
//}

// 一个可以使用各种可调用对象的模板函数
//template<typename Callable>
//void processFunction(Callable func, const std::string& message)
//{
//	func(message);
//}
//
//// 普通函数
//void printFunction(const std::string& message)
//{
//	std::cout << "普通函数输出：" << message << std::endl;
//}
//
//// 仿函数
//struct printFunctor
//{
//	void operator()(const std::string& message)
//	{
//		std::cout << "仿函数输出：" << message << std::endl;
//	}
//};
//
//int main()
//{
//	// lambda表达式
//	auto printLambda = [](const std::string& message) {
//		std::cout << "lambda表达式输出：" << message << std::endl;
//	};
//	std::string msg = "hello world";
//
//	processFunction(printFunction, msg);
//	processFunction(printFunctor(), msg);
//	processFunction(printLambda, msg);
//}

//using Callable = std::function<void(std::string)>;
//void processFunction(const Callable& func, const std::string& message)
//{
//	func(message);
//}
//
//// 普通函数
//void printFunction(const std::string& message)
//{
//	std::cout << "普通函数输出：" << message << std::endl;
//}
//
//// 仿函数
//struct printFunctor
//{
//	void operator()(const std::string& message)
//	{
//		std::cout << "仿函数输出：" << message << std::endl;
//	}
//};
//
//int main()
//{
//	// lambda表达式
//	auto printLambda = [](const std::string& message) {
//		std::cout << "lambda表达式输出：" << message << std::endl;
//	};
//	std::string msg = "hello world";
//	
//	std::vector<Callable> callArray = {
//		printFunction,
//		printFunctor(),
//		printLambda
//	};
//
//	for (const auto& func : callArray)
//	{
//		processFunction(func, msg);
//	}
//}

//class plus
//{
//public:
//	static int plusi(int x, int y)
//	{
//		return x + y;
//	}
//	double plusd(double x, double y)
//	{
//		return x + y;
//	}
//};
//
//int main()
//{
//	// 包装静态成员函数
//	std::function<int(int, int)> f1 = plus::plusi;
//	// 包装非静态成员函数
//	std::function<double(plus*, double, double)> f2 = &plus::plusd;
//
//	std::cout << f1(1, 2) << std::endl;
//	
//	plus pls;
//	std::cout << f2(&pls, 1.1, 2.2) << std::endl;
//
//	return 0;
//}

// 使用举例


int Plus(int a, int b)
{
    return a + b;
}
class Sub
{
public:
    int sub(int a, int b)
    {
        return a - b;
    }
};

// int main()
// {
//     // 1.表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
//     std::function<int(int, int)> func1 = std::bind(Plus, placeholders::_1,
//         placeholders::_2);
//     //auto func = std::bind(Plus, placeholders::_1, placeholders::_2);

//     // 2.func2的类型为 function<void(int, int, int)> 与func1类型一样
//     //表示绑定函数 plus 的第一，二为： 1， 2
//     auto func2 = std::bind(Plus, 1, 2);
//     cout << func1(1, 2) << endl;
//     cout << func2() << endl;
//     Sub s;

//     // 3.绑定成员函数
//     std::function<int(int, int)> func3 = std::bind(&Sub::sub, s, placeholders::_1, placeholders::_2);

//     // 4.参数调换顺序
//     std::function<int(int, int)> func4 = std::bind(&Sub::sub, s,
//         placeholders::_2, placeholders::_1);
//     cout << func3(1, 2) << endl;
//     cout << func4(1, 2) << endl;

//     return 0;
// }